package com.microservice.wechat.client;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.microservice.wechat.config.WechatApiConfig;
import com.microservice.wechat.dto.ArticleInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 微信API客户端
 * 用于调用微信公众号相关API（使用 RestTemplate）
 */
@Slf4j
@Component
public class WechatApiClient {

    @Autowired
    private WechatApiConfig apiConfig;

    private final RestTemplate restTemplate;

    public WechatApiClient() {
        this.restTemplate = new RestTemplate();
    }

    /**
     * 获取所有账号的历史文章列表（支持多账号、多页，只获取7天内的文章）
     * 
     * @return 文章信息列表
     */
    public List<ArticleInfo> getHistoryArticles() {
        log.info("开始获取历史文章列表（最近7天），账号数: {}, 每账号最大页数: {}", 
                apiConfig.getBizList().size(), apiConfig.getMaxPage());
        List<ArticleInfo> allArticles = new ArrayList<>();

        // 计算7天前的时间戳
        long sevenDaysAgo = System.currentTimeMillis() / 1000 - 7 * 24 * 60 * 60;

        // 遍历所有账号
        for (String biz : apiConfig.getBizList()) {
            log.info("开始获取账号 {} 的历史文章", biz);
            
            // 遍历所有页面（1-5页）
            for (int page = 1; page <= apiConfig.getMaxPage(); page++) {
                try {
                    List<ArticleInfo> pageArticles = getHistoryArticlesByPage(biz, page);
                    if (CollectionUtils.isEmpty(pageArticles)) {
                        log.info("账号 {} 第 {} 页没有更多文章，停止翻页", biz, page);
                        break;
                    }
                    
                    // 添加所有文章到结果列表
                    allArticles.addAll(pageArticles);
                    log.info("账号 {} 第 {} 页获取到 {} 篇文章", biz, page, pageArticles.size());
                    
                    // 检查当前页最后一篇文章的发布时间
                    ArticleInfo lastArticle = pageArticles.get(pageArticles.size() - 1);
                    if (lastArticle.getPostTime() != null && lastArticle.getPostTime() < sevenDaysAgo) {
                        log.info("账号 {} 第 {} 页最后一篇文章发布时间超过7天（{}），停止翻页", 
                                biz, page, lastArticle.getPublishTime());
                        break;
                    }
                    
                    // 页面之间添加短暂延迟，避免请求过快（200ms，即最多5 QPS）
                    Thread.sleep(200);
                    
                } catch (Exception e) {
                    log.error("获取账号 {} 第 {} 页文章失败", biz, page, e);
                }
            }
        }

        log.info("所有账号历史文章获取完成，共 {} 篇（7天内）", allArticles.size());
        return allArticles;
    }

    /**
     * 获取指定账号指定页的历史文章
     * 
     * @param biz 账号标识
     * @param page 页码
     * @return 文章列表
     */
    private List<ArticleInfo> getHistoryArticlesByPage(String biz, int page) {
        List<ArticleInfo> articles = new ArrayList<>();

        try {
            // 构建请求参数
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("biz", "" );
            requestBody.put("url", "");
            requestBody.put("name", biz);
            requestBody.put("page", page);
            requestBody.put("key", apiConfig.getKey());
            requestBody.put("verifycode", "");

            // 设置请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);

            HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);

            // 发送 POST 请求
            ResponseEntity<String> response = restTemplate.postForEntity(apiConfig.getHistoryUrl(), entity, String.class);

            if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
                String responseBody = response.getBody();
                JSONObject jsonObject = JSON.parseObject(responseBody);
                
                // 根据实际API返回格式解析
                // 返回格式: {"code": 0, "data": [...]}
                if (jsonObject.getInteger("code") == 0 && jsonObject.containsKey("data")) {
                    JSONArray dataArray = jsonObject.getJSONArray("data");
                    if (dataArray != null && dataArray.size() > 0) {
                        for (int i = 0; i < dataArray.size(); i++) {
                            JSONObject item = dataArray.getJSONObject(i);
                            ArticleInfo article = new ArticleInfo();
                            
                            // 根据实际返回字段映射
                            article.setUrl(item.getString("url"));
                            article.setTitle(item.getString("title"));
                            article.setAuthor(""); // 返回数据中没有author字段
                            article.setPublishTime(item.getString("post_time_str"));
                            article.setPostTime(item.getLong("post_time")); // 时间戳（秒）
                            
                            articles.add(article);
                        }
                    }
                } else {
                    log.warn("获取历史文章返回异常，账号: {}, 页码: {}, 返回: {}", 
                            biz, page, responseBody);
                }
            } else {
                log.error("获取历史文章失败，HTTP状态码: {}, 账号: {}, 页码: {}", 
                        response.getStatusCode(), biz, page);
            }
        } catch (Exception e) {
            log.error("调用历史文章API异常，账号: {}, 页码: {}", biz, page, e);
        }

        return articles;
    }

    /**
     * 获取指定文章的阅读量
     * 
     * @param articleUrl 文章URL
     * @return 阅读量
     */
    public Integer getArticleViewCount(String articleUrl) {
        if (!StringUtils.hasText(articleUrl)) {
            return null;
        }

        try {
            // 构建请求参数
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("url", articleUrl);
            requestBody.put("key", apiConfig.getKey());

            // 设置请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);

            HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);

            // 发送 POST 请求
            ResponseEntity<String> response = restTemplate.postForEntity(apiConfig.getViewcountUrl(), entity, String.class);

            if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
                String responseBody = response.getBody();
                JSONObject jsonObject = JSON.parseObject(responseBody);
                
                // 根据实际API返回格式解析
                // 返回格式: {"code": 0, "data": {"read": 100001, "zan": 1988, "looking": 612}}
                if (jsonObject.getInteger("code") == 0 && jsonObject.containsKey("data")) {
                    JSONObject data = jsonObject.getJSONObject("data");
                    if (data != null && data.containsKey("read")) {
                        return data.getInteger("read");
                    }
                } else {
                    log.warn("获取文章阅读量失败: {}, 返回: {}", articleUrl, responseBody);
                }
            } else {
                log.error("获取文章阅读量失败，HTTP状态码: {}, URL: {}", 
                        response.getStatusCode(), articleUrl);
            }
        } catch (Exception e) {
            log.error("调用阅读量API异常, URL: {}", articleUrl, e);
            throw new RuntimeException("获取文章阅读量失败: " + e.getMessage(), e);
        }

        return null;
    }
}
